#include "AtCmd.h"

// 静态缓冲区
xdata char at_cmd_buffer[AT_CMD_BUFFER_SIZE] = {0};// 完整指令

static xdata char at_cmd_param[PARAM_BUFFER_SIZE] = {0}; // 指令参数

static xdata char at_cmd_response[RESPONSE_BUFFER_SIZE] = {0}; // 指令响应

// 指令超时时间
static uint16_t at_cmd_timeout = 10000; // 单位：ms

///*
//* @param cmd: AT指令名称
//* @param param: AT指令参数
//* @param response: 期望的响应字符串
//* @param timeout: 超时时间
//* @return: 无
//*/
//void AT_Command_Applictaion(const char* cmd, const char* param, const char* response, uint16_t timeout) 
//{
//    char* at_cmd = GetAtCommand(cmd, param); // 构造AT指令
//    
//    at_cmd_timeout = timeout; // 设置超时时间
//}


// 构造AT指令
char* GetAtCommand(const char* cmd, const char* param)
{
     /* 格式化缓冲区 */
    memset(at_cmd_buffer, 0, sizeof(at_cmd_buffer)); // 格式化指令缓冲区

    /* 组装AT指令 */
    if((cmd[0] == 'A' && cmd[1] == 'T'))
    {
//		strcat(cmd, "+");
    } else {
        strcat(at_cmd_buffer, "AT+");
    }
    
    strcat(at_cmd_buffer, cmd); // 追加指令名称
    if(param != NULL) {
        strcat(at_cmd_buffer, "="); // 追加参数分隔符
        strcat(at_cmd_buffer, param); // 追加参数
    } 
	strcat(at_cmd_buffer, "\r\n"); // 追加回车换行符
    
    return at_cmd_buffer;
}


#if 0
// 非阻塞AT指令处理器
void AT_ProcessHandler() {
    static uint8_t retry_count = 0; // 指令超时重试次数
	static uint16_t timestamp = 0;
    
    switch(AT_Cmd_State) {
        case AT_IDLE: {
            // AT指令开始处理
            if(at_cmd_start_flag != 0) {
                // 初始化新命令
                UART2_Rx_Buffer_Clear(); // 清空接收缓冲区
								
                AT_Cmd_State = AT_START; // 切换到测试状态
            }
        } break;
        case AT_START: {
            // 发送AT指令
			UART2_Send_String(at_cmd_buffer);

            // 更新状态 发送
            AT_Cmd_State = AT_SENDING;
			// 获取系统时间戳
            timestamp = GetSystemTick(); 
        } break;
        case AT_SENDING: { 
            // 等待数据发送完成（实际需根据硬件标志判断）
            if(Uart2_Send_String_Flag || (GetSystemTick() - timestamp) >= 200) {
				// 发送成功，更新状态 等待回应
                AT_Cmd_State = WAITING_RESPONSE;
                timestamp = GetSystemTick();// 获取系统时间戳
            }
        } break;
        case WAITING_RESPONSE: { 
			if((GetSystemTick() - timestamp) >= at_cmd_timeout) 
			{
				// 检查是否收到OK
				if(strstr(uart2_rx_buffer, AT_CMD_OK) != NULL) { // "AT\r\r\nOK\r\n"
					// 更新状态 指令完成
					// AT_Command_Response_Applictaion(at_cmd_buffer);
					// at_cmd_response_flag = 1;
					AT_Cmd_State = AT_SUCCESS;
				} else if(strstr(uart2_rx_buffer, AT_CMD_ERROR) != NULL) {
					
					AT_Cmd_State = AT_ERROR;	// 更新状态 错误
				}
				// 超时处理
				else {
					AT_Cmd_State = AT_TIMEOUT; // 更新状态 重试
				}
			}
        } break;   
        case AT_SUCCESS: { 
            // 成功处理逻辑
			
			// 处理数据
            Get_Response_Data_Handler();
            

            // 这里可以触发下一个AT指令
            // AT_Cmd_State = AT_IDLE;
        } break;
        case AT_ERROR: {
            
            // retry_count = 0; // 重试次数清零

            // AT_Cmd_State = AT_TIMEOUT; // 超时状态
			
			
			static enum {S0, S1} State = S0;
                    static const uint16_t delay_time = 1000;
                    
                    switch(State) {
                        case S0:
                            timestamp = GetSystemTick(); // 获取系统时间戳
                            State = S1;
                            break;
                        case S1:
                            if((GetSystemTick() - timestamp) >= delay_time) {
                                UART2_Send_String("AT+CBC\r\n"); // 查询信号强度
								at_cmd_start_flag = 0; // 指令开始标志

                                timestamp = GetSystemTick(); // 获取系统时间戳
                            }
                            break;
                        default: {State = S0;} break;
                    } 
			
            } break;
        case AT_TIMEOUT: {
                // 超时重试逻辑
                if(retry_count < 3) {
                    AT_Cmd_State = AT_IDLE;
                    retry_count++; // 重试次数加1
                } else {
                    // 超过重试次数的错误处理
                    ///////// HandleFatalError(); ///////// 
                                
                    static enum {S0, S1} State = S0;
                    static const uint16_t delay_time = 1000;
                    
                    switch(State) {
                        case S0:
                            timestamp = GetSystemTick(); // 获取系统时间戳
                            State = S1;
                            break;
                        case S1:
                            if((GetSystemTick() - timestamp) >= delay_time) {
                                HandleFatalError(); // 触发错误处理
                                
                                timestamp = GetSystemTick(); // 获取系统时间戳
                            }
                            break;
                        default: {State = S0;} break;
                    } 
                }
            } break;
		default: {AT_Cmd_State = AT_IDLE;} break;
    }
}
#endif

